package Data_Structure.List.SystemList;

import java.util.ArrayList;

/**
 * @className: ArrayListSourceCode
 * @author: 芃
 * @description: ArrayList扩容机制底层原码
 * @date: 2023/8/24 10:57
 */
public class ArrayListSourceCode {
    //ArrayList的扩容机制
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();//默认容量为0
        list.add(1);//第一次进行add的时候进行数组容量初始化
        list.get(0);
        list.indexOf(1);
        list.lastIndexOf(1);
        list.add(1,10);
        list.remove(1);
        //第一次初始化为多大呢？
        //对容量为0的数组进行初始化容量 为10
        //当这10个元素放慢了，就会进行1.5倍的扩容
        ArrayList<Integer> list1 = new ArrayList<>(13);//初始容量为13
        //如果调用给定容量的构造方法，那么顺序表的大小就是给定的容量，放满了还是1.5倍的扩容
        /* add方法
        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  确认真实的容量
            elementData[size++] = e;
            return true;
        }

        private void ensureCapacityInternal(int minCapacity) { minCapacity=1
            int capacity = calculateCapacity(elementData, minCapacity)
            ensureExplicitCapacity(capacity);
        }

        private static int calculateCapacity(Object[] elementData, int minCapacity) {
           if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //DEFAULTCAPACITY_EMPTY_ELEMENTDATA = 1
                return Math.max(DEFAULT_CAPACITY, minCapacity);
                //DEFAULT_CAPACITY = 10
                //minCapacity = 1
           }
          return minCapacity;
         }

         private void ensureExplicitCapacity(int minCapacity) {
            modCount++;

            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }*/




    }
    public static void main1(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1,10);
        list.add(3);
        list.add(4);
       /* 指定位置插入add
        public void add(int index, E element) {
            检查插入位置的合法性
            rangeCheckForAdd(index);
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            确认真实的容量
            System.arraycopy(elementData, index, elementData, index + 1,
                    size - index);
            elementData[index] = element;
            size++;
        }*/
        int ret = list.remove(0);
        System.out.println(ret);
        list.set(0,422);
        System.out.println(list);
        list.clear();
        System.out.println(list);
        /* 删除元素
        public E remove(int index) {
            rangeCheck(index);检查下标合法性
            modCount++;
            E oldValue = elementData(index);先存储需要删除的元素
            int numMoved = size - index - 1;计算移动的元素个数
            if (numMoved > 0){
                 System.arraycopy(elementData, index+1, elementData, index,numMoved);进行移动
            }
            elementData[--size] = null; // clear to let GC do its work
            return oldValue;
        }*/
    }
}
